import TimeUtil from '@/common/utils/time.js'

/**
 * 消息中心 - 使用观察者模式管理消息
 * 支持3种消息类型：notification(提醒)、friend(好友)、consultation(咨询)
 */
let messageCenter = {
	chatList: uni.getStorageSync("chatList") || [], // 聊天列表（从本地初始化）
	observerList: [], // 观察者列表
	totalUnReadNum: 0, // 未读消息总数量
	unreadCounts: { // 各类型未读消息数量
		notification: 0,
		friend: 0,
		consultation: 0
	},

	// 1. 添加观察者
	addObserver(observer) {
		const isExist = this.observerList.some(item => item === observer);
		if (!isExist) {
			this.observerList.push(observer);
		}
	},

	// 2. 移除观察者
	removeObserver(observer) {
		this.observerList = this.observerList.filter(item => item !== observer);
	},

	// 3. 更新列表并同步本地+通知观察者
	updateChatList() {
		uni.setStorageSync("chatList", this.chatList);
		this.calculateUnreadCounts();
		this.notifyAll();
	},

	// 4. 通知所有观察者
	notifyAll() {
		console.log("准备通知所有观察者，观察者数量：", this.observerList.length);
		this.observerList.forEach((observer, index) => {
			console.log("通知观察者", index, ":", observer);
			if (typeof observer.update === 'function') {
				try {
					observer.update();
					console.log("观察者", index, "更新成功");
				} catch (error) {
					console.error("观察者", index, "更新失败：", error);
				}
			} else {
				console.warn("观察者", index, "没有update方法");
			}
		});
	},

	// 5. 保存消息（添加重复校验和消息类型支持）
	saveMessage(message) {
		// 前置校验：仅要求 id 和 fromId，其他字段允许缺省
		if (!message || !message.id || !message.fromId) {
			return;
		}

		// 确定消息类型（notification/friend/consultation）
		const messageType = message.messageType || message.chatType || 'friend'; // 默认为好友消息

		// 查找是否已存在对应聊天
		const targetChatIndex = this.chatList.findIndex(chat =>
			chat.id === message.fromId && chat.chatType === messageType
		);

		// 去重
		if (targetChatIndex !== -1) {
			const targetChat = this.chatList[targetChatIndex];
			const isMsgDuplicate = targetChat.list.some(msg => msg.id === message.id);
			if (isMsgDuplicate) {
				return;
			}
		}

		// 安全回填 name/headImg：若消息缺失，则使用已存在聊天信息
		const existingName = targetChatIndex !== -1 ? (this.chatList[targetChatIndex].user.name || "") : "";
		const existingHeadImg = targetChatIndex !== -1 ? (this.chatList[targetChatIndex].user.headImg || "") : "";
		const safeName = message.name || existingName || "未知用户";
		const safeHeadImg = message.headImg || existingHeadImg || "/static/images/user-avatar.png";

		// 检测消息是否为图片（优先使用原始消息的 isImage 字段，否则通过URL判断）
		const isImage = message.isImage !== undefined
			? message.isImage
			: (() => {
				// 如果没有 isImage 字段，通过检测 URL 是否为图片URL来判断
				const msgContent = message.msg || "";
				if (!msgContent) return false;

				// 检查是否为图片URL（常见的图片扩展名或OSS URL）
				const imageExtensions = ['.jpg', '.jpeg', '.png', '.gif', '.webp', '.bmp', '.svg'];
				const lowerMsg = msgContent.toLowerCase().trim();

				// 如果消息内容看起来像URL
				if (lowerMsg.startsWith('http://') || lowerMsg.startsWith('https://')) {
					// 检查URL是否包含图片扩展名
					const hasImageExt = imageExtensions.some(ext => {
						// 检查扩展名是否在URL路径中（排除查询参数）
						const urlPath = lowerMsg.split('?')[0]; // 移除查询参数
						return urlPath.endsWith(ext) || urlPath.includes(ext + '/');
					});

					// 检查是否是OSS URL（通常包含图片路径标识）
					const isOssUrl = lowerMsg.includes('oss-cn') ||
						lowerMsg.includes('aliyuncs.com') ||
						lowerMsg.includes('/post/') ||
						lowerMsg.includes('/avatar/') ||
						lowerMsg.includes('/image');

					return hasImageExt || isOssUrl;
				}

				// 如果不是URL，检查是否包含图片扩展名（可能是相对路径）
				return imageExtensions.some(ext => lowerMsg.includes(ext));
			})();

		// 规范化消息结构
		const formattedMsg = {
			id: message.id,
			fromId: message.fromId,
			msg: message.msg || "",
			time: message.time || new Date().toLocaleString(),
			type: "receive",
			headImg: safeHeadImg,
			isImage: isImage // 保留图片标识
		};

		// 处理聊天列表逻辑
		if (targetChatIndex !== -1) {
			// 找到已有聊天，追加消息
			const targetChat = this.chatList[targetChatIndex];
			targetChat.list.push(formattedMsg);
			targetChat.user.headImg = safeHeadImg;
			targetChat.user.name = safeName;
			// 更新action字段（如果存在）
			if (message.action) {
				targetChat.user.action = message.action;
			}
			targetChat.lastTime = this.formatTime(formattedMsg.time);
			targetChat.lastMessage = formattedMsg.msg; // 添加最后一条消息内容

			// 将当前聊天移到列表首位
			const [movedChat] = this.chatList.splice(targetChatIndex, 1);
			this.chatList.unshift(movedChat);
		} else {
			// 新增聊天
			// 将安全回填后的字段写回到 originalMessage，以便 addChat 使用
			const originalMessage = { ...message, name: safeName, headImg: safeHeadImg };
			this.chatList.unshift(this.addChat(formattedMsg, originalMessage, messageType));
		}

		// 更新列表并通知观察者
		this.updateChatList();

		// 显示消息通知（仅当不在聊天页面时）
		this.showMessageNotification({ ...message, name: safeName }, messageType);
	},

	// 6. 新建聊天对象（支持3种消息类型）
	addChat(formattedMsg, originalMessage, chatType) {
		return {
			id: originalMessage.fromId,
			chatType: chatType, // notification/friend/consultation
			user: {
				id: originalMessage.fromId,
				name: originalMessage.name || "未知用户",
				headImg: originalMessage.headImg || "/static/images/user-avatar.png",
				action: originalMessage.action || "" // 添加action字段，默认为空字符串
			},
			lastTime: this.formatTime(formattedMsg.time),
			lastMessage: formattedMsg.msg,
			readTime: "",
			readNum: 0,
			list: [formattedMsg]
		};
	},

	// 7. 更新聊天的已读时间和已读数量
	setReadTime(chat) {
		if (!chat || !chat.id) {
			return;
		}

		const targetChatIndex = this.chatList.findIndex(c =>
			c.id === chat.id && c.chatType === chat.chatType
		);

		if (targetChatIndex !== -1) {
			this.chatList[targetChatIndex].readTime = chat.readTime || new Date().toLocaleString();
			this.chatList[targetChatIndex].readNum = chat.readNum;

			// 同步本地
			uni.setStorageSync("chatList", this.chatList);

			// 重新计算各类型未读数量（这会更新 totalUnReadNum 和 unreadCounts）
			this.calculateUnreadCounts();

			// 通知观察者
			this.notifyAll();
		}
	},

	// 8. 计算各类型未读消息数量
	calculateUnreadCounts(updateBadge = false) {
		const counts = {
			notification: 0,
			friend: 0,
			consultation: 0
		};

		this.chatList.forEach(chat => {
			const unreadCount = chat.list.length - (chat.readNum || 0);
			if (unreadCount > 0) {
				counts[chat.chatType] = (counts[chat.chatType] || 0) + unreadCount;
				console.log('未读消息统计 - 类型:', chat.chatType, '数量:', unreadCount, '聊天对象:', chat);
			}
		});

		this.unreadCounts = counts;
		this.totalUnReadNum = counts.notification + counts.friend + counts.consultation;

		console.log('各类型未读消息数量统计:', counts, '总未读数:', this.totalUnReadNum);

		// 只在明确需要时才更新 TabBar 徽章
		if (updateBadge) {
			this.setTabBarBadge();
		}

		// 保存未读数量到本地
		uni.setStorageSync("unreadCounts", this.unreadCounts);
		uni.setStorageSync("totalUnReadNum", this.totalUnReadNum);
	},

	// 9. 获取指定类型的未读消息数量
	getUnreadCountByType(type) {
		return this.unreadCounts[type] || 0;
	},

	// 10. 设置TabBar未读徽章
	setTabBarBadge() {
		this.totalUnReadNum = Math.max(0, this.totalUnReadNum);

		// 获取当前页面路径，检查是否是 TabBar 页面
		const pages = getCurrentPages();
		if (pages.length === 0) return;

		const currentPage = pages[pages.length - 1];
		const currentRoute = currentPage.route || '';

		// TabBar 页面列表
		const tabBarPages = [
			'pages/index/index',
			'pages/mall/mall',
			'pages/assistant/assistant',
			'pages/message/message',
			'pages/mine/mine'
		];

		// 只在 TabBar 页面或即将跳转到 TabBar 页面时更新徽章
		const isTabBarPage = tabBarPages.includes(currentRoute);

		// 使用 setTimeout 延迟执行，避免页面切换过程中的错误
		setTimeout(() => {
			if (this.totalUnReadNum > 0) {
				const badgeText = this.totalUnReadNum > 99 ? "99+" : this.totalUnReadNum.toString();
				uni.setTabBarBadge({
					index: 3,
					text: badgeText,
					fail: () => {
						// 静默失败
					}
				});
			} else if (isTabBarPage) {
				// 只在 TabBar 页面时移除徽章
				uni.removeTabBarBadge({
					index: 3,
					fail: () => {
						// 静默失败
					}
				});
			}
		}, isTabBarPage ? 0 : 300);
	},

	// 11. 减少未读消息数
	subUnReadNum(num) {
		const reduceNum = Math.max(0, parseInt(num, 10) || 0);
		this.totalUnReadNum = Math.max(0, this.totalUnReadNum - reduceNum);
		this.setTabBarBadge();
		uni.setStorageSync("totalUnReadNum", this.totalUnReadNum);
	},

	// 12. 初始化未读消息数
	initUnReadNum() {
		const savedUnReadNum = uni.getStorageSync("totalUnReadNum");
		const savedUnreadCounts = uni.getStorageSync("unreadCounts");

		if (savedUnReadNum !== null && savedUnReadNum !== undefined) {
			this.totalUnReadNum = Math.max(0, parseInt(savedUnReadNum, 10) || 0);
		}

		if (savedUnreadCounts) {
			this.unreadCounts = savedUnreadCounts;
		} else {
			// 如果没有保存的未读数量，重新计算
			this.calculateUnreadCounts();
		}

		this.setTabBarBadge();
	},

	// 13. 格式化时间
	formatTime(time) {
		if (TimeUtil.transferTime) {
			return TimeUtil.transferTime(time);
		}
		return time;
	},

	// 14. 获取指定类型的聊天列表
	getChatListByType(type) {
		return this.chatList.filter(chat => chat.chatType === type);
	},

	// 15. 获取最后一条消息内容
	getLastMessage(chat) {
		if (!chat || !chat.list || chat.list.length === 0) {
			return "";
		}
		return chat.list[chat.list.length - 1].msg;
	},

	// 16. 获取聊天的未读消息数量
	getUnreadCount(chat) {
		if (!chat || !chat.list) {
			return 0;
		}
		return Math.max(0, chat.list.length - chat.readNum);
	},

	// 17. 显示消息通知
	showMessageNotification(message, messageType) {
		// 获取当前页面路径
		const pages = getCurrentPages();
		if (pages.length === 0) return;

		const currentPage = pages[pages.length - 1];
		const currentRoute = currentPage.route || '';

		// 如果当前在聊天页面，且是与发送者的聊天，不显示通知
		if (currentRoute === 'pages/chat/chat') {
			// 通过页面参数判断是否是当前聊天对象
			const options = currentPage.options || {};
			if (options.id === message.fromId && options.chatType === messageType) {
				console.log('当前正在与发送者聊天，不显示通知');
				return;
			}
		}

		// 显示系统通知
		const typeNameMap = {
			'notification': '系统提醒',
			'friend': '好友消息',
			'consultation': '咨询消息'
		};
		const typeName = typeNameMap[messageType] || '新消息';

		uni.showToast({
			title: `[${typeName}] ${message.name || '未知用户'}: ${message.msg}`,
			icon: 'none',
			duration: 3000
		});

		// 播放提示音（可选）
		// uni.vibrateLong() // 震动
	}
};

// 初始化：页面加载时恢复未读消息数
messageCenter.initUnReadNum();

export default messageCenter;